// src/utils/userAdapter.js

// 后端响应数据适配
export const adaptResponse = (backendResponse) => {
    console.log('🔍 === Spring Boot ResponseData分析 ===')
    console.log('完整响应:', backendResponse)

    if (backendResponse && typeof backendResponse === 'object') {
        console.log('响应字段:', Object.keys(backendResponse))
        console.log('message:', backendResponse.message)
        console.log('data:', backendResponse.data)
    }

    // 分析ResponseData结构
    const analysisResult = analyzeResponseData(backendResponse)

    console.log('🔍 分析结果:', analysisResult)
    return analysisResult
}

// 分析ResponseData格式 - 针对标准Spring Boot ResponseData
const analyzeResponseData = (response) => {
    if (!response) {
        console.log('❌ 响应为空')
        return {
            success: false,
            data: null,
            message: '空响应'
        }
    }

    console.log('🔍 开始分析响应格式...')

    // 情况1：标准 Spring Boot ResponseData 格式
    if (response.message !== undefined && response.data !== undefined) {
        console.log('✅ 检测到标准ResponseData格式')

        // 关键修复：根据后端逻辑判断成功状态
        let success = false;
        let message = response.message || '';

        // 根据消息内容判断成功状态
        if (message.includes('成功') || message.includes('登录成功') || message.includes('正常')) {
            success = true;
        } else if (message.includes('失败') || message.includes('错误') || message.includes('不存在')) {
            success = false;
        } else {
            // 默认如果有数据且没有错误消息就认为是成功
            success = response.data !== null && response.data !== undefined;
        }

        return {
            success: success,
            data: response.data,
            message: message
        }
    }

    // 情况2：直接返回用户对象（登录成功时）
    if (response.id !== undefined || response.phone !== undefined) {
        console.log('✅ 检测到直接用户对象格式')
        return {
            success: true,
            data: response,
            message: '登录成功'
        }
    }

    // 情况3：只有 message 字段，没有 data（操作结果）
    if (response.message !== undefined && response.data === undefined) {
        console.log('✅ 检测到只有message字段的格式')
        const success = response.message.includes('成功') || !response.message.includes('失败')
        return {
            success: success,
            data: null,
            message: response.message
        }
    }

    // 情况4：检查是否有 code 字段的常见格式
    if (response.code !== undefined) {
        console.log('✅ 检测到code字段格式')
        const success = response.code === 200 || response.code === 0
        return {
            success: success,
            data: response.data || response.result || null,
            message: response.message || response.msg || ''
        }
    }

    console.warn('❌ 无法识别的响应格式:', response)
    return {
        success: false,
        data: response,
        message: '响应格式无法识别'
    }
}

// 用户数据适配
export const adaptUserData = (backendUser) => {
    if (!backendUser) {
        console.log('❌ adaptUserData: 用户数据为空')
        return null
    }

    console.log('🔍 原始用户数据:', backendUser)

    try {
        const userData = {
            id: backendUser.id || backendUser.userId || Math.random().toString(36).substr(2, 9),
            username: backendUser.username || backendUser.name || `用户${backendUser.phone}`,
            email: backendUser.email || '',
            phone: backendUser.phone || '',
            role: mapRole(backendUser.role),
            status: mapStatus(backendUser.status),
            farmName: backendUser.farmName || getDefaultFarmName(backendUser.role),
            location: backendUser.location || backendUser.address || '',
            createdAt: backendUser.createTime || backendUser.createdAt || new Date().toISOString(),
            lastLogin: backendUser.lastLoginTime || backendUser.lastLogin || new Date().toISOString()
        }

        console.log('✅ 适配后用户数据:', userData)
        return userData
    } catch (error) {
        console.error('❌ 用户数据适配错误:', error)
        return null
    }
}

// 用户列表数据适配器
export const adaptUserList = (data) => {
    if (!data) {
        console.log('❌ 用户列表数据为空')
        return []
    }

    console.log('🔧 原始用户列表数据:', data)

    // 如果数据是数组，直接处理
    if (Array.isArray(data)) {
        const adaptedUsers = data.map(user => adaptUserData(user)).filter(user => user !== null)
        console.log('✅ 适配后的用户列表:', adaptedUsers)
        return adaptedUsers
    }

    // 如果数据是对象且有 data 属性
    if (data.data && Array.isArray(data.data)) {
        const adaptedUsers = data.data.map(user => adaptUserData(user)).filter(user => user !== null)
        console.log('✅ 适配后的用户列表:', adaptedUsers)
        return adaptedUsers
    }

    // 如果数据是单个用户对象
    if (typeof data === 'object' && (data.id || data.phone)) {
        const adaptedUser = adaptUserData(data)
        return adaptedUser ? [adaptedUser] : []
    }

    console.warn('⚠️ 未知的用户列表数据格式:', data)
    return []
}

// 角色映射 - 确保只有 ROLE_ADMIN 和 USER
const mapRole = (backendRole) => {
    console.log(`🔍 原始角色: ${backendRole}`)

    if (!backendRole) {
        console.log('⚠️ 角色为空，默认映射为: USER')
        return 'USER'
    }

    // 统一转换为大写进行比较
    const upperRole = (backendRole || '').toUpperCase()

    // 明确的管理员标识
    const adminIdentifiers = ['ROLE_ADMIN', 'ADMIN', '管理员']

    // 明确的用户标识
    const userIdentifiers = ['USER', '用户', '普通用户']

    // 检查是否为管理员
    if (adminIdentifiers.some(admin => upperRole.includes(admin))) {
        console.log('✅ 映射为: ROLE_ADMIN')
        return 'ROLE_ADMIN'
    }

    // 检查是否为用户
    if (userIdentifiers.some(user => upperRole.includes(user))) {
        console.log('✅ 映射为: USER')
        return 'USER'
    }

    // 默认返回 USER
    console.log('⚠️ 未知角色，默认映射为: USER')
    return 'USER'
}

// 状态映射
const mapStatus = (backendStatus) => {
    const statusMap = {
        'ACTIVE': 'active',
        'INACTIVE': 'inactive',
        'BANNED': 'inactive',
        'active': 'active',
        'inactive': 'inactive',
        '1': 'active',
        '0': 'inactive',
        'true': 'active',
        'false': 'inactive'
    }
    const mappedStatus = statusMap[backendStatus] || 'active'
    console.log(`🔍 状态映射: ${backendStatus} → ${mappedStatus}`)
    return mappedStatus
}

// 根据角色生成默认农场名
const getDefaultFarmName = (role) => {
    const farmMap = {
        'ROLE_ADMIN': '智慧农场管理平台',
        'USER': '个人农场'
    }
    return farmMap[role] || '我的农场'
}

// 登录请求数据适配（前端 -> 后端）
export const adaptLoginRequest = (frontendCredentials) => {
    console.log('🔍 登录请求适配:', frontendCredentials)
    return {
        phone: frontendCredentials.phone || frontendCredentials.username,
        password: frontendCredentials.password
    }
}

// 注册请求数据适配（前端 -> 后端）
export const adaptRegisterRequest = (frontendUserData) => {
    console.log('🔍 注册请求适配:', frontendUserData)
    return {
        phone: frontendUserData.phone || frontendUserData.username,
        password: frontendUserData.password,
        role: frontendUserData.role || 'USER'
    }
}